use rustc_serialize::{Encoder, Encodable};
use core::{SourceId, Summary, PackageId};
-use util::{CargoError, CargoResult, Cfg, CfgExpr, ChainError, human};
+use util::{CargoError, CargoResult, Cfg, CfgExpr, ChainError, human, Config};
/// Information about a dependency requested by a Cargo manifest.
/// Cheap to copy.
/// Attempt to create a `Dependency` from an entry in the manifest.
pub fn parse(name: &str,
version: Option<&str>,
- source_id: &SourceId) -> CargoResult<DependencyInner> {
+ source_id: &SourceId,
+ _config: &Config) -> CargoResult<DependencyInner> {
let (specified_req, version_req) = match version {
Some(v) => (true, try!(DependencyInner::parse_with_deprecated(v))),
None => (false, VersionReq::any())
/// Attempt to create a `Dependency` from an entry in the manifest.
pub fn parse(name: &str,
version: Option<&str>,
- source_id: &SourceId) -> CargoResult<Dependency> {
- DependencyInner::parse(name, version, source_id).map(|di| {
+ source_id: &SourceId,
+ config: &Config) -> CargoResult<Dependency> {
+ DependencyInner::parse(name, version, source_id, config).map(|di| {
di.into_dependency()
})
}
Box::new(self.packages.iter().map(|&(ref p, _)| p))
}
- pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
+ pub fn get(&self, id: &PackageId, config: &Config) -> CargoResult<&Package> {
let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
internal(format!("couldn't find `{}` in package set", id))
}));
let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
internal(format!("couldn't find source for `{}`", id))
}));
- let pkg = try!(source.download(id).chain_error(|| {
+ let pkg = try!(source.download(id, config).chain_error(|| {
human("unable to get packages from source")
}));
assert!(slot.fill(pkg).is_ok());
/// See also `core::Source`.
pub trait Registry {
/// Attempt to find the packages that match a dependency request.
- fn query(&mut self, name: &Dependency) -> CargoResult<Vec<Summary>>;
+ fn query(&mut self, name: &Dependency, config: &Config) -> CargoResult<Vec<Summary>>;
/// Returns whether or not this registry will return summaries with
/// checksums listed.
}
impl Registry for Vec<Summary> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, _config: &Config) -> CargoResult<Vec<Summary>> {
Ok(self.iter().filter(|summary| dep.matches(*summary))
.cloned().collect())
}
}
impl Registry for Vec<Package> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, _config: &Config) -> CargoResult<Vec<Summary>> {
Ok(self.iter().filter(|pkg| dep.matches(pkg.summary()))
.map(|pkg| pkg.summary().clone()).collect())
}
}
impl<'a, T: ?Sized + Registry + 'a> Registry for Box<T> {
- fn query(&mut self, name: &Dependency) -> CargoResult<Vec<Summary>> {
- (**self).query(name)
+ fn query(&mut self, name: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
+ (**self).query(name, config)
}
}
#[cfg(test)]
pub mod test {
use core::{Summary, Registry, Dependency};
- use util::{CargoResult};
+ use util::{CargoResult, Config};
pub struct RegistryBuilder {
summaries: Vec<Summary>,
}
impl Registry for RegistryBuilder {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
debug!("querying; dep={:?}", dep);
let overrides = self.query_overrides(dep);
if overrides.is_empty() {
- self.summaries.query(dep)
+ self.summaries.query(dep, config)
} else {
Ok(overrides)
}
use core::{PackageId, Registry, SourceId, Summary, Dependency};
use core::PackageIdSpec;
-use util::{CargoResult, Graph, human, CargoError};
+use util::{CargoResult, Graph, human, CargoError, Config};
use util::profile;
use util::ChainError;
use util::graph::{Nodes, Edges};
/// Builds the list of all packages required to build the first argument.
pub fn resolve(summaries: &[(Summary, Method)],
replacements: &[(PackageIdSpec, Dependency)],
- registry: &mut Registry) -> CargoResult<Resolve> {
+ registry: &mut Registry,
+ config: &Config) -> CargoResult<Resolve> {
let cx = Context {
resolve_graph: Graph::new(),
resolve_features: HashMap::new(),
replacements: replacements,
};
let _p = profile::start(format!("resolving"));
- let cx = try!(activate_deps_loop(cx, registry, summaries));
+ let cx = try!(activate_deps_loop(cx, registry, summaries, config));
let mut resolve = Resolve {
graph: cx.resolve_graph,
registry: &mut Registry,
parent: Option<&Rc<Summary>>,
candidate: Candidate,
- method: &Method)
+ method: &Method,
+ config: &Config)
-> CargoResult<Option<DepsFrame>> {
if let Some(parent) = parent {
cx.resolve_graph.link(parent.package_id().clone(),
}
};
- let deps = try!(cx.build_deps(registry, &candidate, method));
+ let deps = try!(cx.build_deps(registry, &candidate, method, config));
Ok(Some(DepsFrame {
parent: candidate,
/// dependency graph, cx.resolve is returned.
fn activate_deps_loop<'a>(mut cx: Context<'a>,
registry: &mut Registry,
- summaries: &[(Summary, Method)])
+ summaries: &[(Summary, Method)],
+ config: &Config)
-> CargoResult<Context<'a>> {
// Note that a `BinaryHeap` is used for the remaining dependencies that need
// activation. This heap is sorted such that the "largest value" is the most
let summary = Rc::new(summary.clone());
let candidate = Candidate { summary: summary, replace: None };
remaining_deps.extend(try!(activate(&mut cx, registry, None, candidate,
- method)));
+ method, config)));
}
// Main resolution loop, this is the workhorse of the resolution algorithm.
None => return Err(activation_error(&cx, registry, &parent,
&dep,
&cx.prev_active(&dep),
- &candidates)),
+ &candidates,
+ config)),
Some(candidate) => candidate,
}
}
trace!("{}[{}]>{} trying {}", parent.name(), cur, dep.name(),
candidate.summary.version());
remaining_deps.extend(try!(activate(&mut cx, registry, Some(&parent),
- candidate, &method)));
+ candidate, &method, config)));
}
Ok(cx)
parent: &Summary,
dep: &Dependency,
prev_active: &[Rc<Summary>],
- candidates: &[Candidate]) -> Box<CargoError> {
+ candidates: &[Candidate],
+ config: &Config) -> Box<CargoError> {
if candidates.len() > 0 {
let mut msg = format!("failed to select a version for `{}` \
(required by `{}`):\n\
let mut msg = msg;
let all_req = semver::VersionReq::parse("*").unwrap();
let new_dep = dep.clone_inner().set_version_req(all_req).into_dependency();
- let mut candidates = match registry.query(&new_dep) {
+ let mut candidates = match registry.query(&new_dep, config) {
Ok(candidates) => candidates,
Err(e) => return e,
};
fn build_deps(&mut self,
registry: &mut Registry,
candidate: &Summary,
- method: &Method) -> CargoResult<Vec<DepInfo>> {
+ method: &Method,
+ config: &Config) -> CargoResult<Vec<DepInfo>> {
// First, figure out our set of dependencies based on the requsted set
// of features. This also calculates what features we're going to enable
// for our own dependencies.
// Next, transform all dependencies into a list of possible candidates
// which can satisfy that dependency.
let mut deps = try!(deps.into_iter().map(|(dep, features)| {
- let mut candidates = try!(self.query(registry, &dep));
+ let mut candidates = try!(self.query(registry, &dep, config));
// When we attempt versions for a package, we'll want to start at
// the maximum version and work our way down.
candidates.sort_by(|a, b| {
/// return.
fn query(&self,
registry: &mut Registry,
- dep: &Dependency) -> CargoResult<Vec<Candidate>> {
- let summaries = try!(registry.query(dep));
+ dep: &Dependency,
+ config: &Config) -> CargoResult<Vec<Candidate>> {
+ let summaries = try!(registry.query(dep, config));
summaries.into_iter().map(Rc::new).map(|summary| {
// get around lack of non-lexical lifetimes
let summary2 = summary.clone();
Some(replacement) => replacement,
};
- let mut summaries = try!(registry.query(dep)).into_iter();
+ let mut summaries = try!(registry.query(dep, config)).into_iter();
let s = try!(summaries.next().chain_error(|| {
human(format!("no matching package for override `{}` found\n\
location searched: {}\n\
/// The download method fetches the full package for each name and
/// version specified.
- fn download(&mut self, package: &PackageId) -> CargoResult<Package>;
+ fn download(&mut self, package: &PackageId
, config: &Config) -> CargoResult<Package>;
/// Generates a unique string which represents the fingerprint of the
/// current state of the source.
(**self).update()
}
- fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
- (**self).download(id)
+ fn download(&mut self, id: &PackageId
, config: &Config) -> CargoResult<Package> {
+ (**self).download(id, config)
}
fn fingerprint(&self, pkg: &Package) -> CargoResult<String> {
}
let mut registry = try!(PackageRegistry::new(opts.config));
- let resolve = try!(ops::resolve_ws(&mut registry, ws));
+ let resolve = try!(ops::resolve_ws(&mut registry, ws, opts.config));
let packages = ops::get_resolved_packages(&resolve, registry);
let profiles = try!(ws.current()).manifest().profiles();
for spec in opts.spec {
// Translate the spec to a Package
let pkgid = try!(resolve.query(spec));
- let pkg = try!(packages.get(&pkgid));
+ let pkg = try!(packages.get(&pkgid, ws.config()));
// Generate all relevant `Unit` targets for this package
for target in pkg.targets() {
// First, resolve the root_package's *listed* dependencies, as well as
// downloading and updating all remotes and such.
- let resolve = try!(ops::resolve_ws(&mut registry, ws));
+ let resolve = try!(ops::resolve_ws(&mut registry, ws, ws.config()));
// Second, resolve with precisely what we're doing. Filter out
// transitive dependencies if necessary, specify features, handle
let resolved_with_overrides =
try!(ops::resolve_with_previous(&mut registry, ws,
method, Some(&resolve), None,
- &specs));
+ &specs, ws.config()));
let packages = ops::get_resolved_packages(&resolved_with_overrides,
registry);
};
let to_builds = try!(pkgids.iter().map(|id| {
- packages.get(id)
+ packages.get(id, config)
}).collect::<CargoResult<Vec<_>>>());
let mut general_targets = Vec::new();
/// Executes `cargo fetch`.
pub fn fetch<'a>(ws: &Workspace<'a>) -> CargoResult<(Resolve, PackageSet<'a>)> {
let mut registry = try!(PackageRegistry::new(ws.config()));
- let resolve = try!(ops::resolve_ws(&mut registry, ws));
+ let resolve = try!(ops::resolve_ws(&mut registry, ws, ws.config()));
let packages = get_resolved_packages(&resolve, registry);
for id in resolve.iter() {
- try!(packages.get(id));
+ try!(packages.get(id, ws.config()));
}
Ok((resolve, packages))
}
let mut registry = try!(PackageRegistry::new(ws.config()));
let resolve = try!(ops::resolve_with_previous(&mut registry, ws,
Method::Everything,
- None, None, &[]));
+ None, None, &[], ws.config()));
try!(ops::write_pkg_lockfile(ws, &resolve));
Ok(())
}
Method::Everything,
Some(&previous_resolve),
Some(&to_avoid),
- &[]));
+ &[],
+ ws.config()));
// Summarize what is changing for the user.
let print_change = |status: &str, msg: String| {
let map = try!(SourceConfigMap::new(config));
let (pkg, source) = if source_id.is_git() {
try!(select_pkg(GitSource::new(source_id, config), source_id,
- krate, vers, &mut |git| git.read_packages()))
+ krate, vers, config, &mut |git| git.read_packages()))
} else if source_id.is_path() {
let path = source_id.url().to_file_path().ok()
.expect("path sources must have a valid path");
specify an alternate source", path.display()))
}));
try!(select_pkg(PathSource::new(&path, source_id, config),
- source_id, krate, vers,
+ source_id, krate, vers, config,
&mut |path| path.read_packages()))
} else {
try!(select_pkg(try!(map.load(source_id)),
- source_id, krate, vers,
+ source_id, krate, vers, config,
&mut |_| Err(human("must specify a crate to install from \
crates.io, or use --path or --git to \
specify alternate source"))))
source_id: &SourceId,
name: Option<&str>,
vers: Option<&str>,
+ config: &Config,
list_all: &mut FnMut(&mut T) -> CargoResult<Vec<Package>>)
-> CargoResult<(Package, Box<Source + 'a>)>
where T: Source + 'a
try!(source.update());
match name {
Some(name) => {
- let dep = try!(Dependency::parse(name, vers, source_id));
- let deps = try!(source.query(&dep));
+ let dep = try!(Dependency::parse(name, vers, source_id, config));
+ let deps = try!(source.query(&dep, config));
match deps.iter().map(|p| p.package_id()).max() {
Some(pkgid) => {
- let pkg = try!(source.download(pkgid));
+ let pkg = try!(source.download(pkgid, config));
Ok((pkg, Box::new(source)))
}
None => {
let (packages, resolve) = deps;
let packages = try!(packages.package_ids()
- .map(|i| packages.get(i).map(|p| p.clone()))
+ .map(|i| packages.get(i, ws.config()).map(|p| p.clone()))
.collect());
Ok(ExportInfo {
}
}));
}
- for dep in try!(self.dep_targets(&unit)) {
+ for dep in try!(self.dep_targets(&unit, self.config)) {
try!(self.visit_crate_type(&dep, crate_types));
}
Ok(())
for unit in units {
try!(self.walk_used_in_plugin_map(unit,
unit.target.for_host(),
- &mut visited));
+ &mut visited,
+ self.config));
}
Ok(())
}
fn walk_used_in_plugin_map(&mut self,
unit: &Unit<'a>,
is_plugin: bool,
- visited: &mut HashSet<(Unit<'a>, bool)>)
+ visited: &mut HashSet<(Unit<'a>, bool)>,
+ config: &Config)
-> CargoResult<()> {
if !visited.insert((*unit, is_plugin)) {
return Ok(())
if is_plugin {
self.used_in_plugin.insert(*unit);
}
- for unit in try!(self.dep_targets(unit)) {
+ for unit in try!(self.dep_targets(unit, config)) {
try!(self.walk_used_in_plugin_map(&unit,
is_plugin || unit.target.for_host(),
- visited));
+ visited,
+ config));
}
Ok(())
}
/// For a package, return all targets which are registered as dependencies
/// for that package.
- pub fn dep_targets(&self, unit: &Unit<'a>) -> CargoResult<Vec<Unit<'a>>> {
+ pub fn dep_targets(&self, unit: &Unit<'a>, config: &Config) -> CargoResult<Vec<Unit<'a>>> {
if unit.profile.run_custom_build {
return self.dep_run_custom_build(unit)
} else if unit.profile.doc {
- return self.doc_deps(unit);
+ return self.doc_deps(unit, config);
}
let id = unit.pkg.package_id();
true
})
}).filter_map(|id| {
- match self.get_package(id) {
+ match self.get_package(id, config) {
Ok(pkg) => {
pkg.targets().iter().find(|t| t.is_lib()).map(|t| {
Ok(Unit {
profile: &self.profiles.dev,
..*unit
};
- let deps = try!(self.dep_targets(&tmp));
+ let deps = try!(self.dep_targets(&tmp, self.config));
Ok(deps.iter().filter_map(|unit| {
if !unit.target.linkable() || unit.pkg.manifest().links().is_none() {
return None
}
/// Returns the dependencies necessary to document a package
- fn doc_deps(&self, unit: &Unit<'a>) -> CargoResult<Vec<Unit<'a>>> {
+ fn doc_deps(&self, unit: &Unit<'a>, config: &Config) -> CargoResult<Vec<Unit<'a>>> {
let deps = self.resolve.deps(unit.pkg.package_id()).filter(|dep| {
unit.pkg.dependencies().iter().filter(|d| {
d.name() == dep.name()
}
})
}).map(|dep| {
- self.get_package(dep)
+ self.get_package(dep, config)
});
// To document a library, we depend on dependencies actually being
}
/// Gets a package for the given package id.
- pub fn get_package(&self, id: &PackageId) -> CargoResult<&'a Package> {
- self.packages.get(id)
+ pub fn get_package(&self, id: &PackageId, config: &Config) -> CargoResult<&'a Package> {
+ self.packages.get(id, config)
}
/// Get the user-specified linker for a particular host or target
if !unit.target.is_custom_build() && unit.pkg.has_custom_build() {
add_to_link(&mut ret, unit.pkg.package_id(), unit.kind);
}
- for unit in try!(cx.dep_targets(unit)).iter() {
+ for unit in try!(cx.dep_targets(unit, cx.config)).iter() {
let dep_scripts = try!(build(out, cx, unit));
if unit.target.for_host() {
// elsewhere. Also skip fingerprints of binaries because they don't actually
// induce a recompile, they're just dependencies in the sense that they need
// to be built.
- let deps = try!(cx.dep_targets(unit));
+ let deps = try!(cx.dep_targets(unit, cx.config));
let deps = try!(deps.iter().filter(|u| {
!u.target.is_custom_build() && !u.target.is_bin()
}).map(|unit| {
fn dependencies<'cfg>(&self, cx: &Context<'a, 'cfg>)
-> CargoResult<Vec<Key<'a>>> {
let unit = Unit {
- pkg: try!(cx.get_package(self.pkg)),
+ pkg: try!(cx.get_package(self.pkg, cx.config)),
target: self.target,
profile: self.profile,
kind: self.kind,
};
- let targets = try!(cx.dep_targets(&unit));
+ let targets = try!(cx.dep_targets(&unit, cx.config));
Ok(targets.iter().filter_map(|unit| {
// Binaries aren't actually needed to *compile* tests, just to run
// them, so we don't include this dependency edge in the job graph.
if !unit.target.is_lib() { continue }
// Include immediate lib deps as well
- for unit in try!(cx.dep_targets(unit)).iter() {
+ for unit in try!(cx.dep_targets(unit, cx.config)).iter() {
let pkgid = unit.pkg.package_id();
if !unit.target.is_lib() { continue }
if unit.profile.doc { continue }
drop(p);
// Be sure to compile all dependencies of this target as well.
- for unit in try!(cx.dep_targets(unit)).iter() {
+ for unit in try!(cx.dep_targets(unit, cx.config)).iter() {
try!(compile(cx, jobs, unit));
}
Ok(())
cmd.env("OUT_DIR", &layout.build_out(unit.pkg));
}
- for unit in try!(cx.dep_targets(unit)).iter() {
+ for unit in try!(cx.dep_targets(unit, cx.config)).iter() {
if unit.target.linkable() && !unit.profile.doc {
try!(link_to(cmd, cx, unit));
}
use core::registry::PackageRegistry;
use core::resolver::{self, Resolve, Method};
use ops;
-use util::CargoResult;
+use util::{CargoResult, Config};
/// Resolve all dependencies for the specified `package` using the previous
/// lockfile as a guide if present.
///
/// This function will also write the result of resolution as a new
/// lockfile.
-pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace)
+pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace, config: &Config)
-> CargoResult<Resolve> {
let prev = try!(ops::load_pkg_lockfile(ws));
let resolve = try!(resolve_with_previous(registry, ws,
Method::Everything,
- prev.as_ref(), None, &[]));
+ prev.as_ref(), None, &[], config));
// Avoid writing a lockfile if we are `cargo install`ing a non local package.
if ws.current_opt().map(|pkg| pkg.package_id().source_id().is_path()).unwrap_or(true) {
method: Method,
previous: Option<&'a Resolve>,
to_avoid: Option<&HashSet<&'a PackageId>>,
- specs: &[PackageIdSpec])
+ specs: &[PackageIdSpec],
+ config: &Config)
-> CargoResult<Resolve> {
// Here we place an artificial limitation that all non-registry sources
// cannot be locked at more than one revision. This means that if a git
None => root_replace.to_vec(),
};
- let mut resolved = try!(resolver::resolve(&summaries, &replace, registry));
+ let mut resolved = try!(resolver::resolve(&summaries, &replace, registry, config));
if let Some(previous) = previous {
try!(resolved.merge_from(previous));
}
}
impl<'cfg> Registry for DirectorySource<'cfg> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, _config: &Config) -> CargoResult<Vec<Summary>> {
let packages = self.packages.values().map(|p| &p.0);
let matches = packages.filter(|pkg| dep.matches(pkg.summary()));
let summaries = matches.map(|pkg| pkg.summary().clone());
Ok(())
}
- fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
+ fn download(&mut self, id: &PackageId
, _config: &Config) -> CargoResult<Package> {
self.packages.get(id).map(|p| &p.0).cloned().chain_error(|| {
human(format!("failed to find package with id: {}", id))
})
}
impl<'cfg> Registry for GitSource<'cfg> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
let src = self.path_source.as_mut()
.expect("BUG: update() must be called before query()");
- src.query(dep)
+ src.query(dep, config)
}
}
self.path_source.as_mut().unwrap().update()
}
- fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
+ fn download(&mut self, id: &PackageId
, config: &Config) -> CargoResult<Package> {
trace!("getting packages for package id `{}` from `{:?}`", id,
self.remote);
self.path_source.as_mut()
.expect("BUG: update() must be called before get()")
- .download(id)
+ .download(id, config)
}
fn fingerprint(&self, _pkg: &Package) -> CargoResult<String> {
}
impl<'cfg> Registry for PathSource<'cfg> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
- self.packages.query(dep)
+ fn query(&mut self, dep: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
+ self.packages.query(dep, config)
}
}
Ok(())
}
- fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
+ fn download(&mut self, id: &PackageId
, _config: &Config) -> CargoResult<Package> {
trace!("getting packages; id={}", id);
let pkg = self.packages.iter().find(|pkg| pkg.package_id() == id);
}
/// Return the hash listed for a specified PackageId.
- pub fn hash(&mut self, pkg: &PackageId) -> CargoResult<String> {
+ pub fn hash(&mut self, pkg: &PackageId, config: &Config) -> CargoResult<String> {
let key = (pkg.name().to_string(), pkg.version().to_string());
if let Some(s) = self.hashes.get(&key) {
return Ok(s.clone())
}
// Ok, we're missing the key, so parse the index file to load it.
- try!(self.summaries(pkg.name()));
+ try!(self.summaries(pkg.name(), config));
self.hashes.get(&key).chain_error(|| {
internal(format!("no hash listed for {}", pkg))
}).map(|s| s.clone())
///
/// Returns a list of pairs of (summary, yanked) for the package name
/// specified.
- pub fn summaries(&mut self, name: &str) -> CargoResult<&Vec<(Summary, bool)>> {
+ pub fn summaries(&mut self, name: &str, config: &Config) -> CargoResult<&Vec<(Summary, bool)>> {
if self.cache.contains_key(name) {
return Ok(self.cache.get(name).unwrap());
}
- let summaries = try!(self.load_summaries(name));
+ let summaries = try!(self.load_summaries(name, config));
let summaries = summaries.into_iter().filter(|summary| {
summary.0.package_id().name() == name
}).collect();
Ok(self.cache.get(name).unwrap())
}
- fn load_summaries(&mut self, name: &str) -> CargoResult<Vec<(Summary, bool)>> {
+ fn load_summaries(&mut self, name: &str, config: &Config) -> CargoResult<Vec<(Summary, bool)>> {
let (path, _lock) = if self.locked {
let lock = self.path.open_ro(Path::new(INDEX_LOCK),
self.config,
try!(f.read_to_string(&mut contents));
let ret: CargoResult<Vec<(Summary, bool)>>;
ret = contents.lines().filter(|l| l.trim().len() > 0)
- .map(|l| self.parse_registry_package(l))
+ .map(|l| self.parse_registry_package(l, config))
.collect();
ret.chain_error(|| {
internal(format!("failed to parse registry's information \
/// package.
///
/// The returned boolean is whether or not the summary has been yanked.
- fn parse_registry_package(&mut self, line: &str)
+ fn parse_registry_package(&mut self, line: &str, config: &Config)
-> CargoResult<(Summary, bool)> {
let RegistryPackage {
name, vers, cksum, deps, features, yanked
} = try!(json::decode::<RegistryPackage>(line));
let pkgid = try!(PackageId::new(&name, &vers, &self.source_id));
let deps: CargoResult<Vec<Dependency>> = deps.into_iter().map(|dep| {
- self.parse_registry_dependency(dep)
+ self.parse_registry_dependency(dep, config)
}).collect();
let deps = try!(deps);
let summary = try!(Summary::new(pkgid, deps, features));
}
/// Converts an encoded dependency in the registry to a cargo dependency
- fn parse_registry_dependency(&self, dep: RegistryDependency)
+ fn parse_registry_dependency(&self, dep: RegistryDependency, config: &Config)
-> CargoResult<Dependency> {
let RegistryDependency {
name, req, features, optional, default_features, target, kind
} = dep;
let dep = try!(DependencyInner::parse(&name, Some(&req),
- &self.source_id));
+ &self.source_id, config));
let kind = match kind.as_ref().map(|s| &s[..]).unwrap_or("") {
"dev" => Kind::Development,
"build" => Kind::Build,
}
impl<'cfg> Registry for RegistryIndex<'cfg> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
let mut summaries = {
- let summaries = try!(self.summaries(dep.name()));
+ let summaries = try!(self.summaries(dep.name(), config));
summaries.iter().filter(|&&(_, yanked)| {
dep.source_id().precise().is_some() || !yanked
}).map(|s| s.0.clone()).collect::<Vec<_>>()
_ => true,
}
});
- summaries.query(dep)
+ summaries.query(dep, config)
}
fn supports_checksums(&self) -> bool {
}
impl<'cfg> Registry for RegistrySource<'cfg> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
// If this is a precise dependency, then it came from a lockfile and in
// theory the registry is known to contain this version. If, however, we
// come back with no summaries, then our registry may need to be
// updated, so we fall back to performing a lazy update.
if dep.source_id().precise().is_some() && !self.updated {
- if try!(self.index.query(dep)).is_empty() {
+ if try!(self.index.query(dep, config)).is_empty() {
try!(self.do_update());
}
}
- self.index.query(dep)
+ self.index.query(dep, config)
}
fn supports_checksums(&self) -> bool {
Ok(())
}
- fn download(&mut self, package: &PackageId) -> CargoResult<Package> {
- let hash = try!(self.index.hash(package));
+ fn download(&mut self, package: &PackageId
, config: &Config) -> CargoResult<Package> {
+ let hash = try!(self.index.hash(package, config));
let path = try!(self.ops.download(package, &hash));
let path = try!(self.unpack_package(package, &path).chain_error(|| {
internal(format!("failed to unpack package `{}`", package))
}));
let mut src = PathSource::new(&path, &self.source_id, self.config);
try!(src.update());
- src.download(package)
+ src.download(package, config)
}
fn fingerprint(&self, pkg: &Package) -> CargoResult<String> {
use core::{Source, Registry, PackageId, Package, Dependency, Summary, SourceId};
-use util::{CargoResult, ChainError, human};
+use util::{CargoResult, ChainError, human, Config};
pub struct ReplacedSource<'cfg> {
to_replace: SourceId,
}
impl<'cfg> Registry for ReplacedSource<'cfg> {
- fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+ fn query(&mut self, dep: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
let dep = dep.clone().map_source(&self.to_replace, &self.replace_with);
- let ret = try!(self.inner.query(&dep).chain_error(|| {
+ let ret = try!(self.inner.query(&dep, config).chain_error(|| {
human(format!("failed to query replaced source `{}`",
self.to_replace))
}));
})
}
- fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
+ fn download(&mut self, id: &PackageId
, config: &Config) -> CargoResult<Package> {
let id = id.with_source_id(&self.replace_with);
- let pkg = try!(self.inner.download(&id).chain_error(|| {
+ let pkg = try!(self.inner.download(&id, config).chain_error(|| {
human(format!("failed to download replaced source `{}`",
self.to_replace))
}));
};
let version = details.version.as_ref().map(|v| &v[..]);
- let mut dep = try!(DependencyInner::parse(name, version, &new_source_id));
+ let mut dep = try!(DependencyInner::parse(name, version, &new_source_id, cx.config));
dep = dep.set_features(details.features.unwrap_or(Vec::new()))
.set_default_features(details.default_features.unwrap_or(true))
.set_optional(details.optional.unwrap_or(false))
use cargo::core::source::{SourceId, GitReference};
use cargo::core::dependency::Kind::{self, Development};
use cargo::core::{Dependency, PackageId, Summary, Registry};
-use cargo::util::{CargoResult, ToUrl};
+use cargo::util::{CargoResult, ToUrl, Config};
use cargo::core::resolver::{self, Method};
fn resolve<R: Registry>(pkg: PackageId, deps: Vec<Dependency>,
registry: &mut R)
-> CargoResult<Vec<PackageId>> {
+ let config = Config::default().unwrap();
let summary = Summary::new(pkg.clone(), deps, HashMap::new()).unwrap();
let method = Method::Everything;
Ok(try!(resolver::resolve(&[(summary, method)],
&[],
- registry)).iter().map(|p| {
+ registry,
+ &config)).iter().map(|p| {
p.clone()
}).collect())
}
fn to_dep(self) -> Dependency {
let url = "http://example.com".to_url().unwrap();
let source_id = SourceId::for_registry(&url);
- Dependency::parse(self, Some("1.0.0"), &source_id).unwrap()
+ let config = Config::default().unwrap();
+ Dependency::parse(self, Some("1.0.0"), &source_id, &config).unwrap()
}
}
fn dep_req(name: &str, req: &str) -> Dependency {
let url = "http://example.com".to_url().unwrap();
let source_id = SourceId::for_registry(&url);
- Dependency::parse(name, Some(req), &source_id).unwrap()
+ let config = Config::default().unwrap();
+ Dependency::parse(name, Some(req), &source_id, &config).unwrap()
}
fn dep_loc(name: &str, location: &str) -> Dependency {
let url = location.to_url().unwrap();
let master = GitReference::Branch("master".to_string());
let source_id = SourceId::for_git(&url, master);
- Dependency::parse(name, Some("1.0.0"), &source_id).unwrap()
+ let config = Config::default().unwrap();
+ Dependency::parse(name, Some("1.0.0"), &source_id, &config).unwrap()
}
fn dep_kind(name: &str, kind: Kind) -> Dependency {
dep(name).clone_inner().set_kind(kind).into_dependency()
projects / cargo.git / commitdiff